package com.star.links.Utils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;

import com.star.links.R;

import com.star.links.views.BlockImage;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class ImageUtils {
    // 保存所有连连看图片资源值(int类型)
    private static List<Integer> imageValues = getImageValues();

    //获取连连看所有图片的ID（约定所有图片ID以p_开头）
    public static List<Integer> getImageValues() {
        try {
            // 得到R.drawable所有的属性, 即获取drawable目录下的所有图片
            Field[] drawableFields = R.drawable.class.getFields();
            List<Integer> imageValues = new ArrayList<Integer>();
            for (Field field : drawableFields) {
                // 如果该Field的名称以p_开头
                if (field.getName().indexOf("img_") != -1) {
                    imageValues.add(field.getInt(R.drawable.class));
                }
            }
            // 将所有图片ID随机“洗牌”,避免每次出现固定的几张图片
            Collections.shuffle(imageValues);
            return imageValues;
        } catch (Exception e) {
            return null;
        }
    }

    public static List<Integer> getAppointKindNumImageValue(List<Integer> imageResourceValues,
                                                       int speciesNum,int size)
    {
        List<Integer> res=new ArrayList<>();
        if(size%2!=0){
            size+=1;
        }
        int temp=size/2;
        int remainder=temp%speciesNum;
        int merchant=temp/speciesNum;
        for(int i=0;i<merchant;i++)
        {
            res.addAll(imageResourceValues.subList(0,speciesNum));
        }
        for(int j=0;j<remainder;j++){
            res.add(imageResourceValues.get(j));
        }
        res.addAll(res);
        // 将所有图片ID随机“洗牌”
        Collections.shuffle(res);
        return res;
    }


    /**
     * 从某个集合中随机选取size张图片
     * @param imageResourceValues
     * @param size
     * @return
     */
    public static List<Integer> getRandomValues(List<Integer> imageResourceValues,
                                                int size)
    {
        // 创建一个随机数生成器
        Random random = new Random();
        // 创建结果集合
        List<Integer> randomImages = new ArrayList<Integer>();
        for (int i = 0; i < size; i++)
        {
            try
            {
                // 随机获取一个数字，小于imageValues.size()的数值
                int index = random.nextInt(imageResourceValues.size());
                // 从图片ID集合中获取该图片对象
                Integer image = imageResourceValues.get(index);
                // 添加到结果集中
                randomImages.add(image);
            }
            catch (IndexOutOfBoundsException e)
            {
                return randomImages;
            }
        }
        return randomImages;
    }



    /**
     * 从资源目录中随机获取size张图片
     * @param size
     * @return
     */
    public static List<Integer> getPlayValues(int size)
    {
        if (size % 2 != 0)
        {
            // 如果该数除2有余数，将size加1
            size += 1;
        }
        // 再从所有的图片值中随机获取size的一半数量
        List<Integer> playImageValues = getRandomValues(imageValues, size / 2);
        // 将playImageValues集合的元素增加一倍（保证所有图片都有与之配对的图片）
        playImageValues.addAll(playImageValues);
        // 将所有图片ID随机“洗牌”
        Collections.shuffle(playImageValues);
        return playImageValues;
    }


    public static Bitmap imageZoom(Bitmap bitmap, double newWidth, double newHeight) {

        //获取这个图片的宽和高
        float width = bitmap.getWidth();
        float height = bitmap.getHeight();

        //创建操作图片用的matrix对象
        Matrix matrix = new Matrix();

        //计算宽高缩放率
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;

        //压缩Bitmap
        matrix.postScale(scaleWidth, scaleHeight);
        return Bitmap.createBitmap(bitmap, 0, 0, (int) width, (int) height, matrix, true);
    }


    /**
     * 从资源目录随机获取size张图片并转为BlockImage对象
     * @param context
     * @param size
     * @return
     */
    public static List<BlockImage> getPlayImages(Context context, int speciesNum,int size)
    {
        // 获取图片ID组成的集合
        List<Integer> imageResourceValues = getAppointKindNumImageValue(imageValues,speciesNum,size);
        List<BlockImage> blockImages = new ArrayList<BlockImage>();
        // 遍历每个图片ID
        for (Integer value : imageResourceValues)
        {
            // 加载图片
            Bitmap bitmapTemp = BitmapFactory.decodeResource(context.getResources(),  value);
            bitmapTemp=imageZoom(bitmapTemp,110,110);
            // 封装图片ID与图片本身
            BlockImage blockImage = new BlockImage(bitmapTemp, value);
            blockImages.add(blockImage);
        }
        return blockImages;
    }
}
